.TH std::flush 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::flush \- std::flush

.SH Synopsis
   Defined in header <ostream>
   template< class CharT, class Traits >
   std::basic_ostream<CharT, Traits>& flush( std::basic_ostream<CharT, Traits>& os );

   Flushes the output sequence os as if by calling os.flush().

   This is an output-only I/O manipulator, it may be called with an expression such as
   out << std::flush for any out of type std::basic_ostream.

.SH Notes

   This manipulator may be used to produce an incomplete line of output immediately,
   e.g. when displaying output from a long-running process, logging activity of
   multiple threads or logging activity of a program that may crash unexpectedly. An
   explicit flush of std::cout is also necessary before a call to std::system, if the
   spawned process performs any screen I/O (a common example is std::system("pause") on
   Windows). In most other usual interactive I/O scenarios, std::endl is redundant when
   used with std::cout because any input from std::cin, output to std::cerr, or program
   termination forces a call to std::cout.flush().

   When a complete line of output needs to be flushed, the std::endl manipulator may be
   used.

   When every output operation needs to be flushed, the std::unitbuf manipulator may be
   used.

.SH Parameters

   os - reference to output stream

.SH Return value

   os (reference to the stream after manipulation).

.SH Example

   Without std::flush, the output would be the same, but may not appear in real time.


// Run this code

 #include <chrono>
 #include <iostream>

 template<typename Diff>
 void log_progress(Diff d)
 {
     std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(d) << " ... "
               << std::flush;
 }

 int main()
 {
     volatile int sink = 0;

     auto t1 = std::chrono::high_resolution_clock::now();
     for (int j = 0; j < 5; ++j)
     {
         for (int n = 0; n < 10000; ++n)
             for (int m = 0; m < 20000; ++m)
                 sink += m * n; // do some work
         auto now = std::chrono::high_resolution_clock::now();
         log_progress(now - t1);
     }
     std::cout << '\\n';
 }

.SH Possible output:

 567ms ... 1137ms ... 1707ms ... 2269ms ... 2842ms ...

.SH See also

   unitbuf   controls whether output is flushed after each operation
   nounitbuf \fI(function)\fP
   endl      outputs '\\n' and flushes the output stream
             \fI(function template)\fP
   flush     synchronizes with the underlying storage device
             \fI(public member function of std::basic_ostream<CharT,Traits>)\fP
